<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>

</body>

</html>
<script>
    //声明一个名为fun1的函数
    function fun1() {
        console.log('函数fun1成功被调用');
    }
    fun1()//调用函数
    fun1()//再次调用函数
    function fun2(a, b) {//封装一个名为fun2的函数
        //作用是可以进行加法运算
        //a,b是形参，10，20是实参
        //实参如果是基本数据类型例如(number.string.bol)
        //在函数中修改参的值原数据值不受影响，
        // 如果是(arr.obj)等引用数据类型，会修改原数据值
        return a + b
    }
    console.log(fun2(10, 20));
    let a = 10
    function fun3(n) {
        n++
        console.log(n);
    }
    fun3(a)
    console.log(a);

    let obj = { name: '张三', sex: '女' }
    function fun4(information) {
        information.name = '李四'
    }
    fun4(obj)
    console.log(obj);
    //变量式声明函数
    let fun5 = function () {
        console.log('成功调用');
    }
    fun5();
    //6.匿名函数  ;号不能省略，会冲突   自调用函数
    (function (a, b) {
        console.log('我是匿名函数');
        console.log(a + b);
    })(10, 20)
    //参数作用域
    function fun6(a, b) {
        console.log(a, b);
    }
    // fun6(b)//报错
    //参数默认值
    function fun7(str, num) {
        num = num == undefined ? 0 : num
        str = str || 'Hello,world'
        console.log(str, '-----', num);
    }
    fun7('ok', 20)//不传实参则用默认值，若传实参则用传的值进行输出
    //对位传参
    function fun8(name, age, sex, job, height) {
        console.log(`姓名:${name}'-----'年龄:${age}'-----'性别:${sex}'-----'工作:${job}'-----'身高:${height}`);
    }
    fun8('张三', 15, '男', '程序员', 183)
    // arguments对象
    function fun9(a, b) {
        console.log(arguments);//可通过数组的方法拿去下标的值例如   console.log(arguments[2]);输出的是30
        // arguments = Array.protooype.slice.call(arguments)//将伪数组转换成真正的数组
        // console.log(arguments);
        // arguments.reduce(function(pre,cur){
        //     return pre += cur
        // },0)
        let sum = 0
        for (let i = 0; i < arguments.length; i++) {
            sum += arguments[i]
        }
        console.log(sum);
    }//arguments是一个伪数组，有数组的下标和长度，但不能使用数组的方法
    fun9(10, 20, 30, 50)
    var stu = { name: "张三", major: "软件技术" };
    function test_2(obj) {
        obj.major = "软件工程";
    }
    function test_1(obj) {
        obj.major = '计算机应用'
    }
    test_1(stu)
    console.log(stu.major);
    //函数返回值
    // let arr = [2]
    function fun10() {
        console.log('return之前正常执行');
        return [1, 2, 3, 1, 1, 2]
        console.log('return之后不执行');
    }

    console.log(fun10());
    //变量名的提升
    //闭包函数
    //一定要有作用域
    //一定要在父级作用域进行操作
    //
    // function fun11() {
    //     //函数作用域的嵌套
    //     let i = 10
    //     console.log(i);
    //     function fun12() {
    //         //对父级作用域变量的操作
    //         //计算后会存储在内存中，下次计算会直接从内存中取值
    //         i = i + 10
    //         console.log(i);
    //     }
    //     return fun12
    // }
    // fun11()
    // let fun11back = fun11()
    // fun11back()
    // fun11back()
    // fun11back()
    // fun11back()

    // let num1 = 10, num2 = 20
    // function fun13() {
    //     console.log(num11 + num2);
    // }
    // num2 = 0//调用之前会重新赋值，若调用之后便不会影响
    // fun13()
    //     function fun14(a, b, type) {
    //         let num1 = a
    //         let num2 = b
    //         switch (type) {
    //             case '+':
    //                 return function () {
    //                     console.log(`num1 + num2 = ${num1+num2}`);
    //                 }
    //         }
    //     }
    //     let fun14back = fun14(10,20,'+')
    //     fun14back()
    //     //递归函数
    //     function fun15(n){
    // // console.log(n);
    // if(n<1){
    //     return 1 
    // }else{
    //     // return n * fun15(n-1)//偶和度很高
    //    return n * arguments.callee(n-1)
    // }
    //     }
    //     // fun15(10)
    //     console.log(fun15(10));
    // 5.
    // 6.
    // 7.
    // 8.
</script>